Fixes #16018

A long-standing wildcard-subtyping gap in TypeComparer.compareCaptured was rejecting F[? <: hi] <:< F[hi] for covariant F (dually for contravariant G), even though existential elimination over a variant type constructor admits exactly that widening. The fix consults the wildcard's own bound, intersected with the parameter's declared bound, instead of the declared bound alone — purely additive, mirrors the same lattice operation Scala 2 implements, and closes the original akka-derived ticket along with the broader pattern.

How much have you relied on LLM-based tools in this contribution?

Extensively, for: minimizing the akka reproducer, instrumenting TypeComparer to localize the failing subtype path, identifying the wrong-field consultation (paramBounds(tparam).hi vs arg1.hi), proving the fix is type-theoretically correct, and designing the directional pos / neg matrix. I have personally reviewed every line of the diff, can explain each step, and have stress-tested the fix against the full local CompilationTests suite plus targeted wildcard / match / variance filter subsets before submitting.

How was the solution tested?

New automated tests (including the issue's reproducer).

Run via sbt 'scala3-compiler-bootstrapped/testOnly dotty.tools.dotc.CompilationTests':

• i16018 filter — all five test files (16/16 pass).
• wildcard / match / variance filter subsets — 16/16 each.
• Full CompilationTests run — the residual failures (tests/run/i13358.scala, tests/run/lazy-*.scala, tests/run/t5552.scala, tests/run/t7406.scala, tests/run/isInstanceOf-eval.scala, tests/run/i24553.scala, tests/pos-custom-args/captures/fill-cbn.scala, capture-checking neg suite) all reproduce on main without this change and are caused by JDK 25 environment drift (sun.misc.Unsafe deprecation messages on stdout, the introduction of java.lang.IO, removal of native from Object.wait). Verified by re-running them on a clean main checkout.

Diagnosis — how the bug was located

The ticket and its successive minimizations all reduced to the same symptom: a collect { case g: Sub[…] @unchecked => g; case other => other } over a value derived from a java.lang.Iterable[? <: G[? <: M]] rejects the second case with

Found:    (other : ?N.CAP)
Required: Sub[…] & ?N.CAP
where:    ?N is an unknown value of type scala.runtime.TypeBox[Nothing, G[? <: M]]

Instrumentation of TypeComparer.compareTypeParamRef and addOneBound exposed two layered issues:

Layer 1 — sequential constraint accumulation on the partial-function result variable B. The first case body's pattern-narrowed type Sub[…] ∩ ?N.CAP was added as B's lower bound, after which the second case body's check ?N.CAP <:< B was rejected because ?N.CAP ⊄ Sub[…] ∩ ?N.CAP. The fix point we actually want is B := ⨆ᵢ T_i (the LUB of case body types), namely ?N.CAP.

Layer 2 — and this turned out to be the root cause — even bypassing layer 1, the surrounding adaptation reduced to F[? <: M] <:< F[M] for covariant F (after Seq's covariance). That check went through TypeComparer.compareCaptured and was rejected. A reduced standalone reproduction confirmed the regression independently of pattern matching:

class Box[+M]
def f[M](xs: Seq[Box[? <: M]]): Seq[Box[M]] = xs    // also rejected pre-fix

So the partial-function symptom was downstream of a more fundamental gap in wildcard subtyping under variance. Fixing layer 2 dissolves layer 1, and is what this PR does.

Root cause

TypeComparer.compareCaptured is the fallback for an applied-type argument check when the source argument is a wildcard arg1: TypeBounds and the target argument is a concrete arg2. Pre-fix it asked

v > 0:  isSubType(paramBounds(tparam).hi, arg2)
v < 0:  isSubType(arg2, paramBounds(tparam).lo)

— i.e. it consulted the declared parameter bound, which for an unconstrained T collapses to Any (covariant case) or Nothing (contravariant case), so the conformance check became Any <: arg2 and almost always failed. The wildcard's own bound (arg1.hi / arg1.lo) — which is the only place where the user's intent ? <: hi was recorded — was never consulted.

Type-theoretic justification

Order subtypes (<:) so that larger means more general. For each variance direction, the existential F[? >: lo <: hi] denotes a family of types parameterised by the witness X, and we ask for the least upper bound (⨆) of that family — the smallest type into which every member of the family can be widened. The fact that a single concrete type is the LUB is what makes the widening rule sound (admissibility of existential elimination at a variant position).

Covariant F[+T]. The family is {F[X] | X <: hi}. By covariance,

X₁ <: X₂  ⇒  F[X₁] <: F[X₂]   (functoriality preserves the order)

so the family is order-preserving in X; its LUB is attained at X = hi:

⨆ { F[X] | X <: hi }  =  F[hi]        ⇒   F[? <: hi]  <:  F[hi]

Contravariant G[-T]. The family is {G[X] | X >: lo}. By contravariance,

X₁ <: X₂  ⇒  G[X₂] <: G[X₁]   (functoriality reverses the order)

so the family is order-reversing in X; its LUB is attained at X = lo (note: the supremum sits at the small end of the witness, because the type constructor flips the order):

⨆ { G[X] | X >: lo }  =  G[lo]        ⇒   G[? >: lo]  <:  G[lo]

Both rules use the same lattice operation (LUB) and the same notion of "widening"; the only thing that differs is which witness attains the supremum, because the variance of F / G decides whether the witness ordering and the result ordering agree or disagree.

Invariant positions admit neither widening (the family {F[X] | X <: hi} for invariant F has no nontrivial supremum in the family itself), and mixed variance / bound combinations (covariant + lower, contravariant + upper) similarly have no usable LUB — those cases must remain rejected. This is what tests/neg/i16018c.scala pins.

Scala 2 implements both rules; Scala 3 had regressed.

Fix

In TypeComparer.compareCaptured, consult the wildcard's own bound, intersected (resp. unioned) with the parameter's declared bound. The intersection is the declared-bound guard (a completeness guard, not a soundness one — without it NAIVE = arg1.hi would produce false negatives like rejecting CoBounded[? <: Any] <:< CoBounded[Holder]): if a wildcard is wider than what the parameter permits (e.g. F[T <: Holder] applied to ? <: Any), the effective bound is the tighter of the two.

v > 0:  isSubType(arg1.hi & paramBounds(tparam).hi, arg2)
v < 0:  isSubType(arg2, arg1.lo | paramBounds(tparam).lo)

This is purely additive: it never accepts a subtyping that was already accepted by a different path; it only admits the cases the LUB rule above justifies. Three implementations are distinguishable on the test matrix below:

OLD     : isSubType( paramBounds(tparam).hi,                 arg2 )
NAIVE   : isSubType( arg1.hi,                                arg2 )
THE FIX : isSubType( arg1.hi & paramBounds(tparam).hi,       arg2 )

OLD ignores the wildcard's bound: for unbounded Co[+T] fed ? <: M it asks Any <: M and rejects a valid widening. NAIVE ignores the parameter's declared bound: for CoBounded[+T <: Holder] fed ? <: Any it asks Any <: Holder and rejects another valid widening. All three are sound (none accepts a subtyping that violates the bounds either party records); the distinction is completeness. THE FIX is the intersection — the only one of the three that is also complete on this fragment, admitting every existential elimination justified by variance + bounds.

Tests (directional matrix)

Any future refactor of compareCaptured will turn one of the two halves red the moment any of the three implementations above stops behaving as required.